Multi-core processor

ABSTRACT

A multi-core processor includes a plurality of former-stage cores that perform parallel processing using a plurality of pipelines covering a plurality of stages. In the pipelines, the former-stage cores perform stages ending with an instruction decode stage; stages starting with an instruction execution stage are executed by a latter-stage core. A dynamic load distribution block refers to decode results in the instruction decode stage and controls to assign the latter-stage core with a latter-stage-needed decode result being a decode result whose processing needs to be executed in the latter-stage core.

CROSS REFERENCE TO RELATED APPLICATION

The present application is based on Japanese Patent Application No. 2013-87372 filed on Apr. 18, 2013, the disclosure of which is incorporated herein by reference.

TECHNICAL FIELD

The present disclosure relates to a multi-core processor that is a microprocessor to adopt a multi core configuration.

BACKGROUND ART [Patent Literature 1] JP-2005-507212 A (WO 03/036902 A2) [Patent Literature 2] JP 2005284749 A (US 2005/0240930 A1)

A microprocessor adopting a multi core configuration performs parallel processing of multiple tasks. In order to raise a processing efficiency, it is necessary to schedule the processing order so as to satisfy restrictions (so-called deadline) of the processing time specified to each task. The processing efficiency is decided by how to optimize such scheduling.

For example, Patent Literature 1 discloses a method to realize an efficient task assignment or distribution by using hash values when processing tasks belonging to multiple groups with a multi-core processor. Patent Literature 2 discloses a computer that defines previously an execution sequence of threads and classifies into a grain size that can be exclusively executed, thereby achieving an efficient parallel processing.

Each technology of Patent Literatures 1 and 2 increases an efficiency of assignment of tasks (threads) to each processor core. A task assigned to each processor core is processed sequentially in processing stages corresponding to each core (pipeline processing). However, all the instructions are not performed in all the processing stages. Part of the processing stages may be not performed depending on a kind of instruction. For example, Memory Access (MA) stage is not performed by an inter-register calculation instruction. When this point is taken into consideration, the stages of pipeline processing may have room to raise a processing efficiency.

SUMMARY

It is an object of the present disclosure to provide a mufti-core processor that can raise a processing efficiency by improving efficiency in pipeline processing.

To achieve the above object, according to an example of the present disclosure, a multi-core processor includes a plurality of processor cores and a load distribution processing portion. The plurality of processor cores are to perform parallel processing of a plurality of tasks using a plurality of pipelines each containing a plurality of stages. The pipeline is divided into a former-stage pipeline portion ending with an instruction decode stage, and a latter-stage pipeline portion starting with an instruction execution stage. The load distribution processing portion is to refer to decode results in the instruction decode stage and control to assign the latter-stage pipeline portion with a latter-stage-needed decode result among the decode results, the latter-stage-needed decode result being a decode result whose processing needs to be executed in the latter-stage pipeline portion.

Here, some instructions decoded in the former-stage pipeline portion may not include processing that needs to be performed in the latter-stage pipeline portion. In such a case, the corresponding latter-stage pipeline portion can perform another different instruction. This can provide effective processing.

Further, according to an optional example of the above multi-core processor multi-core processor, when a plurality of instructions decoded in the former-stage pipeline portion are ready to undergo parallel execution, the load distribution processing portion may assign the plurality of instructions to a plurality of latter-stage pipelines and permit the plurality of latter-stage pipelines to perform the parallel execution of the plurality of instructions.

This configuration enables a quick performance of a plurality of instructions to improve a processing efficiency.

BRIEF DESCRIPTION OF THE DRAWINGS

The above and other objects, features, and advantages of the present disclosure will became more apparent from the following detailed description made with reference to the accompanying drawings. In the drawings:

FIG. 1 is a functional block diagram illustrating a configuration of a multi-core processor according to a first embodiment of the present disclosure;

FIG. 2 is a diagram for explaining processing of a dynamic load distribution block;

FIG. 3 is a functional block diagram of the dynamic load distribution block;

FIG. 4 is a diagram illustrating an example of a task information table;

FIGS. 5A to 5C are diagrams for explaining an example of using one latter-stage pipeline portion that performs instructions decoded by two former-stage cores;

FIG. 6 is a functional block diagram illustrating a configuration of a multi-core processor according to a second embodiment of the present disclosure; and

FIG. 7 is a functional block diagram of a dynamic load distribution black according to the second embodiment.

DETAILED DESCRIPTION First Embodiment

With reference to FIG. 1, a multi-core processor 1 according to a first embodiment of the present disclosure includes four former-stage cores 2(1) to 2(4), which configure a former-stage portion of a pipeline (former-stage pipeline portion) for performing or executing parallel processing. The former-stage cores 2(1) to 2(4) are provided with corresponding task queues 3(1) to 3(4). A task distribution block 4 distributes tasks into among the respective task queues 3(1) to 3(4); the tasks are arranged one by one in waiting state to wait for being processed in the respective former-stage cores 2(1) to 2(4). Each former-stage core 2(1) to 2(4) serving as a former-stage pipeline portion executes (i.e., perform) an instruction fetch (IF) stage and an instruction decode (ID) stage.

Distribution control in the task distribution block 4 (new task distribution queue) is performed by a dynamic load distribution block 5 (also referred to as a load distribution processing portion). The dynamic load distribution block 5 distributes a new task to one of the task queues 3(1) to 3(4) depending on decode results in the ID stage (details will be mentioned later). That is, the pipeline has a configuration having a relation as follows:

-   -   (the number of former-stage cores)>(the number of latter-stage         cores).

Instructions decoded at the ID stages of the former-stage cores 2(1) to 2(4) are distributed, for execution, into the latter-stage cores 7(1) to 7(3), which configure a latter-stage pipeline portion via a latter-stage process distribution portion 6. In addition, a register file 8 is provided in between the ID stages and the latter-stage process distribution portion 6; the register file 8 is to be accessed by each former-stage core 2.

The dynamic load distribution block 5 also performs a distribution control of the latter-stage process distribution portion 6. The latter-stage core 7 performs an instruction execution (EX) stage, a Memory Access (MA) stage, and a write back (WB) stage. A memory 9 is provided in between the MA stage and the WB stage. In addition, the WB stage performs writing to the register file 8 while the EX stage similarly performs writing; however, those paths are omitted in the drawing.

With reference to FIG. 2, the dynamic load distribution block 5 totals the shares (i.e., obtains a share total) of the tasks which exist in each task queue 3 in the waiting state. It is noted that the “share” is obtained about each task in the queue 3, and is a ratio of a remaining execution time to a deadline time (processing limit time). The deadline time is decided depending on an application; In order to execute processing of the application not to cause trouble, the execution completion of the task needs to be made within the deadline time. The dynamic load distribution block 5 controls the task distribution block 4 indicated as a symbol of a de-multiplexer so as to distribute a new task into the task queue 3 that has the minimum or lowest share total that totals the shares at this time point.

Further, the dynamic load distribution block 5 controls the latter-stage process distribution portion 6 so as to distribute preferentially the processing of the former-stage core 2 corresponding to the task queue 3 providing the maximum or highest share total that totals the shares to the latter-stage core (EX stage to WB stage). It is noted that FIG. 2 indicates, in general, that the number of former-stage cores is N and the number of latter-stage cores is M (<N).

With reference to FIG. 3, the dynamic load distribution block 5 calculates the total of shares (the share total) for each of task queues 3 based on a task information table in a task information storage 11 indicated in FIG. 4, and sorts the share totals of the respective task queues 3 to be assigned with orders or ranks from the highest share total. FIG. 3 illustrates an example where the queue number 4 is sorted at the 1st rank with the share total of 90%, the queue number 3 is sorted at the 2nd rank with the share total of 87%, the queue number 2 is sorted at the 3rd rank with the share total of 30% . . . To that end, the queue number x, which is sorted at the last rank with the lowest or minimum share total, is assigned with a next new task. Herein, the task queue 3 having the queue number x sorted at the last rank or rank may be referred to as a minimum-shared task queue 3. In addition, the tasks, which are sorted at the first rank (top rank) to the Mth rank, are assigned to the latter-stage cores.

With reference to FIG. 4, the task information table in the storage 11 stores the dynamic execution states of the respective tasks that are classified among “stop (state)” that is a state where execution of a task is stopped; “assigned (state)” that is a state where a task is already assigned or distributed to a task queue 3; and “interrupted (state)” that is a state where execution of a task is interrupted. The task information table in the storage 11 further stores the static processing time information containing the above-mentioned deadline time and remaining execution time, and a worst execution time. Here, the worst execution time signifies a time necessary for completing all the processing of a task when only the processing of the task is executed. In addition, the task information table in the storage 11 further stores, if a task is already assigned, the queue number of a queue to which the task is assigned. In addition, “don't care” is a state where the assignment or distribution of a task to a task queue 3 is unnecessary (dynamic execution state).

In addition, the distribution control to the latter-stage core 7 by the dynamic load distribution block 5 is not limited to the example in FIG. 2. Some instructions do not use the latter-stage core 7 depending on the decode results at the ID stage; this may need to consider a different distribution. Furthermore, some instructions performed by more than one former-stage core 7 can be performed in parallel; this may also need to consider a different distribution. Such distribution will be explained in its operation as below.

FIGS. 5A and 58 each illustrate a comparative example where each of two independent cores performs instructions with an individual independent pipeline. FIG. 5C illustrates an example where the above instructions in FIGS. 5A and 5B are performed with the multi-core processor 1 according to the present embodiment. For example, the core (1) in FIG. 5A performs respective add instructions ADD in the third and the fourth cycles; in contrast, the instructions ADD need not perform a MA stage or another stage subsequent to the MA stage.

In addition, after a branch instruction B is fetched in the third cycle, the branch is executed and a next load instruction LDR is then fetched. Then, an instruction “LDR R3[R0]” loads data from an address indicated by the content in a register R0 into a register R3 in a register file 8. A next instruction “LDRB R4[R3]” loads data from an address indicated by the content in the register R3 into a register R4. The decode of the load instruction LDRB is performed in the 7th cycle, while the execution of the load instruction LDRB is performed not from the 8th cycle but from the 9th cycle where the WB stage (register transfer) related to the load instruction LDR is performed. As a result, a vacancy occurs in the pipeline that starts performing an execution from the 8th cycle.

In addition, in the core (2) illustrated in FIG. 5B, the execution of the instruction LDR starts from the 5th cycle; the execution of the instruction LDRB starts from the 6th cycle; and the execution of the instruction LDRH starts from the 8th cycle. That is, in order to start the execution “LDRB R4[R8, #4]”, it is not necessary to wait for the execution completion of the instruction “LDR R3 [R0]”.

Then, in the core (2) in FIG. 5A, the execution of the instruction LDR starts from the 7th cycle; the execution of the instruction LDRB starts from the 9th cycle; and the execution of the instruction LDRH starts from the 10th cycle. Therefore, the processing of the latter-stage pipeline portions of the two cores (1) and (2) can be performed even if they are put into a single pipeline. As a result, as indicated in FIG. 5C, the dynamic load distribution block 5 performs the distribution or assignment such that the processing of the latter-stage pipeline portions of the two cores (1) and (2) are integrated into one latter-stage pipeline portion of one pipeline.

According to the present embodiment, the multi-core processor 1 includes a plurality of former-stage cores (2) that perform parallel processing using a plurality of pipelines. The former-stage cores 2 perform or execute the stages of the pipeline ending with an instruction decode stage; the latter-stage core 7 performs or executes the stages of the pipeline starting with an instruction execution stage. Further, the dynamic load distribution block 5 refers to decode results in the instruction decode stage and controls to distribute a latter-stage-needed decode result of the former-stage cores 2 to the latter-stage core 7; the latter-stage-needed decode result signifies a decode result that needs to be executed in the latter-stage core 7 among the decode results of the instruction decode stage. Thus, if an instruction decoded at the former-stage pipeline portion does not need to be executed at the latter-stage pipeline portion, the corresponding latter-stage core 7 can execute another different instruction. This can provide the effective processing.

Further, when a plurality of instructions decoded in the former-stage cores 2 are ready to undergo parallel execution, the dynamic load distribution block 5 distributes such the instructions to a plurality of latter-stage cores 7 to undergo the parallel execution. This configuration enables a quick execution of the processing of a plurality of instructions to improve the processing efficiency.

Further, the present embodiment provides a plurality of task queues 3 having one-to-one correspondence to a plurality of former-stage cores 2, each of the plurality of task queues 3 permitting each of the plurality of former-stage cores 2 to execute the tasks one by one; and a task information table in the storage 11 that holds static processing time information about a plurality of tasks and reflects dynamic execution states about the plurality of tasks. In addition, the dynamic load distribution block 5 refers to the task information table in the storage 11 and performs distribution processing of a new task to each of the plurality of task queues 3. That is, the static processing time information is necessary for completing the execution of each task, while the dynamic execution state indicates the execution state of each task at each time. Therefore, the dynamic load distribution block 5 can distribute a new task efficiently based on the information.

To be specific, the dynamic load distribution block 5 calculates, about each task queue 3, a share of each task of the plurality of tasks presently in waiting state using a ratio of a remaining execution time to a processing limit time, and obtains a total of shares (i.e., a share total) that totals the shares of the plurality of tasks in each task queue 3; and finds a minimum-shared task queue 3 that is the task queue 3 providing the lowest share total among the share totals of the plurality of task queues 3, and assigns the found minimum-shared task queue 3 with a next new task. This enables the distribution to equalize the share totals of the respective task queues 3.

In addition, the dynamic load distribution block 5 gives a priority to a high-shared former-stage core 2 that is the former-stage core 2 corresponding to a high-shared task queue 3, which is the task queue 3 providing a higher share total among the share totals of the plurality of task queues 3, to thereby distribute the decode result of the high-shared former-stage core 2 to the latter-stage core 7. This facilitates the processing of the high-shared task queue 3 with a higher share total, thereby equalizing the share totals of the respective task queues 3.

Second Embodiment

Portions identical to those in the first embodiment are assigned with the reference signs identical to those in the first embodiment and omitted from the explanation; the different portions are only explained on a priority basis. As illustrated in FIG. 6, a multi-core processor 21 according to a second embodiment provides a configuration example where the number (e.g., four (4)) of former-stage cores 22 is less than the number (e.g., five (5)) of latter-stage cores 7. It is noted that FIG. 6 omits illustration of a register file 8 and a memory 9.

The former-stage cores 22 according to the second embodiment can perform instructions of fetch and instructions of decode of the tasks in the corresponding task queues in two parallel processing. Therefore, “inst1” and “inst2”, which are inputted from the ID stages into the latter-stage processing distribution portion 23, indicate two instructions that were fetched and decoded in parallel.

The following describes an operation of the second embodiment. As illustrated in FIG. 7, the dynamic load distribution block 24 distributes the queue number 4 to two latter-stage cores 7. Herein, the queue number 4 corresponds to a task queue 3 providing the share total greater than a threshold value of 80%. Such a configuration facilitates the processing of the task queue 3 with a high share total to reduce the shares, thereby equalizing the share totals of the respective task queues 3 and improving the processing efficiency.

The present disclosure is not limited to the embodiments described above and illustrated in the drawings, and can be modified or expanded as follows. The number of former-stage cores or the number of latter-stage cores may be changed depending on individual designs. In the second embodiment, the threshold value of 80% may be change suitably. Further, the second embodiment may provide another configuration example where the former-stage core performs fetching and decoding in three parallel and at least three latter-stage cores perform parallel processing of one task queue.

While the present disclosure has been described with reference to preferred embodiments thereof, it is to be understood that the disclosure is not limited to the preferred embodiments and constructions. The present disclosure is intended to cover various modification and equivalent arrangements. In addition, while the various combinations and configurations, which are preferred, other combinations and configurations, including more, less or only a single element, are also within the spirit and scope of the present disclosure. 

What is claimed is:
 1. A multi-core processor comprising: a plurality of processor cores performing parallel processing of a plurality of tasks using a plurality of pipelines each containing a plurality of stages, the pipeline being divided into a former-stage pipeline portion ending with an instruction decode stage, and a latter-stage pipeline portion starting with an instruction execution stage; and a load distribution processing portion referring to decode results in the instruction decode stage and controlling to assign the latter-stage pipeline portion with a latter-stage-needed decode result among the decode results, the latter-stage-needed decode result being a decode result whose processing needs to be executed in the latter-stage pipeline portion.
 2. The multi-core processor according to claim 1, wherein when a plurality of instructions decoded in the former-stage pipeline portion are ready to undergo parallel execution, the load distribution processing portion assigns the plurality of instructions to a plurality of latter-stage pipelines and permits the plurality of latter-stage pipelines to perform the parallel execution of the plurality of instructions.
 3. The multi-core processor according to claim 1, further comprising: a plurality of queues provided to have one-to-one correspondence to a plurality of former-stage pipeline portions, each of the plurality of queues permitting each of the plurality of former-stage pipeline portions to execute tasks one by one; and a task information storage storing a task information table that holds static processing time information about a plurality of tasks and reflects dynamic execution states about the plurality of tasks, wherein the load distribution processing portion refers to the task information table to perform distribution processing of a new task among the plurality of queues.
 4. The multi-core processor according to claim 3, wherein the load distribution processing portion calculates, with respect to each of the plurality of queues, a share of each of the plurality of tasks presently in waiting state using a ratio of a remaining execution time to a processing limit time, and obtains a share total that totals the shares of the plurality of tasks; and the load distribution processing portion finds a minimum-shared queue that is the queue providing the share total that is minimum among the share totals of the plurality of queues, and assigns the found minimum-shared queue with a next new task.
 5. The multi-core processor according to claim 4, wherein the load distribution processing portion finds a high-shared queue that is the queue providing the share total that is high among the share totals of the plurality of queues, and gives a priority to a high-shared former-stage pipeline portion that is the former-stage pipeline corresponding to the high-shared queue in assigning the latter-stage pipeline portion with the latter-stage-needed decode result in the high-shared former-stage pipeline portion.
 6. The multi-core processor according to claim 4, wherein the load distribution processing portion finds a high-shared queue that is the queue providing the share total that is high among the share totals of the plurality of queues, and gives a priority to a high-shared former-stage pipeline portion that is the former-stage pipeline portion corresponding to the high-shared queue in assigning a plurality of latter-stage pipeline portions with the latter-stage-needed decode result in the high-shared former-stage pipeline portion. 